/**
 * SSE导出插件
 * 基于SSE技术实现的文件导出功能，支持实时进度显示
 * @author SSEDemo
 * @version 1.1.0
 */
(function (window) {
    'use strict';

    class SseExport {
        constructor(options = {}) {
            this.options = {
                sseUrl: '/api/export/sse',
                downloadUrl: '/api/export/download',
                processUrl: options.processUrl || '/api/user/process',
                btnSelector: options.btnSelector || '.export-btn',
                // 添加导出参数配置
                params: options.params || {},
                // 默认的回调函数
                onProgress: options.onProgress || this.defaultProgress,
                onComplete: options.onComplete || this.defaultComplete,
                onError: options.onError || this.defaultError,
                onStart: options.onStart || this.defaultStart
            };

            this.init();
        }

        init() {
            // 初始化导出按钮
            this.btn = document.querySelector(this.options.btnSelector);
            if (!this.btn) return;

            // 保存原始HTML内容
            this.originalHtml = this.btn.innerHTML;

            // 添加必要的样式
            this.addStyles();

            // 改造按钮结构
            this.transformButton();

            // 绑定点击事件
            this.bindExportEvent();
        }

        addStyles() {
            if (document.getElementById('sse-export-styles')) return;

            const style = document.createElement('style');
            style.id = 'sse-export-styles';
            style.textContent = `
                .export-btn {
                    position: relative;
                    min-width: 110px;
                }
                .export-btn:disabled {
                    cursor: default;
                }
                .export-btn-text {
                    position: relative;
                    z-index: 1;
                    display: inline-flex;
                    align-items: center;
                    justify-content: center;
                    gap: 5px;
                }
                .export-btn-progress {
                    position: absolute;
                    top: 0;
                    left: 0;
                    height: 100%;
                    background-color: rgba(0, 0, 0, 0.2);
                    transition: width 0.3s;
                }
            `;
            document.head.appendChild(style);
        }

        transformButton() {
            // 保存按钮原有内容
            const originalContent = this.btn.innerHTML;
            
            this.btn.classList.add('export-btn');
            this.btn.innerHTML = `
                <div class="export-btn-progress"></div>
                <span class="export-btn-text">${originalContent}</span>
            `;

            this.btnText = this.btn.querySelector('.export-btn-text');
            this.btnProgress = this.btn.querySelector('.export-btn-progress');
        }

        // 默认的进度回调
        defaultProgress = (percentage, processed, total) => {
            if (this.btnProgress && this.btnText) {
                this.btnProgress.style.width = percentage + '%';
                // 保存原始内容的第一个元素（图标）
                const icon = this.btnText.querySelector('i');
                this.btnText.innerHTML = icon ? icon.outerHTML + ' ' + percentage + '%' : percentage + '%';
            }
        }

        // 默认的完成回调
        defaultComplete = (taskId) => {
            if (this.btnProgress && this.btnText) {
                this.btnProgress.style.width = '100%';
                // 保存原始内容的第一个元素（图标）
                const icon = this.btnText.querySelector('i');
                this.btnText.innerHTML = icon ? icon.outerHTML + ' 完成' : '完成';

                // 下载文件
                this.downloadFile(taskId);

                // 重置按钮状态
                setTimeout(() => {
                    this.btnProgress.style.width = '0';
                    this.btnText.innerHTML = this.originalHtml;
                    this.btn.disabled = false;
                }, 1000);
            }
        }

        // 默认的错误回调
        defaultError = (message) => {
            if (this.btnText && this.btnProgress) {
                this.btnText.innerHTML = this.originalHtml;
                this.btnProgress.style.width = '0';
                this.btn.disabled = false;
            }
            // 使用 Layui 的消息提示
            if (window.layui && layui.layer) {
                layui.layer.msg('导出失败: ' + message, {icon: 2});
            } else {
                alert('导出失败: ' + message);
            }
        }

        // 默认的开始回调
        defaultStart = () => {
            if (this.btnText && this.btnProgress) {
                // 保存原始内容的第一个元素（图标）
                const icon = this.btnText.querySelector('i');
                this.btnText.innerHTML = icon ? icon.outerHTML + ' 0%' : '0%';
                this.btnProgress.style.width = '0';
            }
        }

        bindExportEvent() {
            this.btn.addEventListener('click', async () => {
                if (this.btn.disabled) return;

                try {
                    this.btn.disabled = true;
                    // 保存原始内容的第一个元素（图标）
                    const icon = this.btnText.querySelector('i');
                    this.btnText.innerHTML = icon ? icon.outerHTML + ' 准备中...' : '准备中...';

                    // 直接使用配置的参数
                    await this.startExport({
                        processUrl: this.options.processUrl,
                        params: this.options.params
                    });
                } catch (error) {
                    console.error('导出失败:', error);
                    this.options.onError(error.message);
                }
            });
        }

        /**
         * 开始导出
         * @param {Object} params 导出参数
         * @returns {Promise} 返回Promise对象
         */
        startExport(params) {
            var self = this;

            // 关闭已存在的连接
            if (self.eventSource) {
                self.eventSource.close();
            }

            // 重置进度条
            if (self.progressBar) {
                self.progressBar.reset();
            }

            return new Promise(function (resolve, reject) {
                // 生成任务ID
                self.taskId = new Date().getTime();

                // 创建SSE连接
                self.eventSource = new EventSource(self.options.sseUrl + '?taskId=' + self.taskId);

                // 监听初始化事件
                self.eventSource.addEventListener('init', function () {
                    // 通知开始
                    self.options.onStart(self.taskId);

                    // 开始处理数据
                    fetch(params.processUrl + "?taskId=" + self.taskId, {
                        method: 'POST',
                        headers: {
                            'Content-Type': 'application/json'
                        },
                        body: JSON.stringify(params.params || {})
                    })
                        .then(function (response) {
                            if (!response.ok) {
                                throw new Error('处理请求失败');
                            }
                            return response.json();
                        })
                        .then(function (data) {
                            resolve(data);
                        })
                        .catch(function (error) {
                            self.options.onError(error.message);
                            if (self.eventSource) {
                                self.eventSource.close();
                            }
                            reject(error);
                        });
                });

                // 监听进度更新
                self.eventSource.addEventListener('progress', function (event) {
                    var data = JSON.parse(event.data);
                    self.options.onProgress(data.percentage, data.processed, data.total);
                });

                // 监听完成事件
                self.eventSource.addEventListener('complete', function () {
                    // 关闭SSE连接
                    self.eventSource.close();
                    self.options.onComplete(self.taskId);
                });

                // 监听错误事件
                self.eventSource.addEventListener('error', function (event) {
                    var message = '导出失败，请重试';
                    if (event.data) {
                        var data = JSON.parse(event.data);
                        message = data.message || message;
                    }

                    // 关闭SSE连接
                    self.eventSource.close();
                    self.options.onError(message);
                    reject(new Error(message));
                });

                // 监听SSE连接错误
                self.eventSource.onerror = function () {
                    var message = 'SSE连接错误，请重试';
                    self.eventSource.close();
                    self.options.onError(message);
                    reject(new Error(message));
                };
            });
        };

        /**
         * 下载文件
         * @param {string} taskId 任务ID，如果不提供则使用当前任务ID
         */
        downloadFile(taskId) {
            taskId = taskId || this.taskId;
            if (!taskId) {
                console.error('没有可用的任务ID');
                return;
            }

            window.location.href = this.options.downloadUrl + "?taskId=" + taskId;
        };

        /**
         * 取消导出
         */
        cancel() {
            if (this.eventSource) {
                this.eventSource.close();
                this.eventSource = null;
            }
        };
    }

    // 暴露到全局
    window.SseExport = SseExport;

})(window); 